package com.example.androidkt.third

import android.provider.Settings.Global
import kotlinx.coroutines.*
import kotlin.system.measureNanoTime
import kotlin.system.measureTimeMillis

fun foo() {
    println(1)
    println(2)
    println(3)
}

fun bar() {
    println(4)
    println(5)
    println(6)
}

fun coroutine(){
    GlobalScope.launch {
        println("携程启动")
        delay(1000)
        println("携程结束")
    }
    Thread.sleep(100)
}

fun coroutine2(){
    runBlocking {
        println("携程启动")
        delay(1000)
        println("携程结束")
    }
}

fun coroutine3(){
    runBlocking {
        launch {
            println("携程11启动")
            delay(1000)
            println("携程11结束")
        }
        launch {
            println("携程22启动")
            delay(1000)
            println("携程22结束")
        }
    }
}

fun coroutine4(){
    val measureNanoTime = measureTimeMillis {
        runBlocking {
            repeat(100000) {
                launch {
                    println("xx")
                }
            }
        }
    }
    println("十万个携程公用时：${measureNanoTime}")
}

// fun printDot(){
//    delay(1)
//}

suspend fun printDot(){
    delay(1)
}

fun printDot1(){
    runBlocking {
        delay(1)
    }
}

suspend fun printDot2() = coroutineScope {
    launch{
        delay(1)
    }
}

fun coroutine5(){
    runBlocking {
        coroutineScope {
            launch {
                for (i in 0..10){
                    println(i)
                    delay(1000)
                }
            }
        }
        println("?????????")
    }
    println("里面执行完毕才执行我")
}

fun coroutine6(){
    runBlocking {
        val await = async {
            5 + 5
        }.await()
        println(await)
    }
}

fun coroutine7(){
    val measureTimeMillis = measureTimeMillis {
        runBlocking {
            val await = async {
                delay(2000)
                5 + 5
            }

            val await1 = async {
                delay(4000)
                5 + 4
            }
            println(await.await())
            println(await1.await())   //上面函数执行完毕之后才会执行下面函数 主要原因是await()
        }
    }
    println("共运行了多久呢/？？？ $measureTimeMillis")
}


/**
* 线程参数有以下3种:。
 * Dispatchers.Defaut 表示会使用一种默认低并发的线程策略，当你要执行的代码属于计算密集型任务时，开启过高的并发反而可能会影响任务的运行效率
 * Dispatchers.10 表示会使用一种较高并发的线程策略，当你要执行的代码大多数时间是阻塞和等待中，比如网络清求时，为了能够支持更高的并发数量
 * Dispatchers.Main 表示不会开启子线程，而是在Android主线程中执行代码。这个值只能在Android项目中便用。我们刚才所学的协程作用域构建器中，除了coroutinescope的数之外，其他所有的函数都可以指定这样一个线程参数，只不过withContext0)函数强制要求指定个线程参数。
* */
fun coroutine8(){
    runBlocking {
        val withContext = withContext(Dispatchers.Default) {
            1 + 2
        }
        withContext
    }
}
//取消携程
fun coroutine9(){
    val job = Job()

    val scope1 = CoroutineScope(job)
    scope1.launch {  }

    val scope2 = CoroutineScope(job)
    scope2.launch {  }

    job.cancel()


}


fun main() { //main函数运行的速度比里面慢
    coroutine7()
}